/*
 * Powered By [rapid-framework]
 * Web Site: http://www.rapid-framework.org.cn
 * Google Code: http://code.google.com/p/rapid-framework/
 * Since 2008 - 2019
 */

package net.dreamlu.db.qo;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Date;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Order;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.hibernate.criterion.MatchMode;
import org.springframework.data.jpa.domain.Specification;
import net.dreamlu.db.po.*;
/**
 *
 * @author lambert.wang email:lambert.wang(a)crediteyes.com
 * @version 1.0
 * @since 1.0
 */
public class AdminQuery extends Admin implements Serializable {
    private static final long serialVersionUID = 3148176768559230877L;
    

	/** 主键id */
	private java.lang.Integer id;	
	private java.lang.Integer notEqId;	
	/** 用户名 */
	private String likeUsernameWithStart;
	private String likeUsernameWithEnd;
	private String likeUsernameWithExact;
	private String likeUsernameWithAnywhere;
	private java.lang.String username;	
	private java.lang.String notEqUsername;	
	/** 密码 */
	private String likePasswordWithStart;
	private String likePasswordWithEnd;
	private String likePasswordWithExact;
	private String likePasswordWithAnywhere;
	private java.lang.String password;	
	private java.lang.String notEqPassword;	
	/** 用户名 */
	private String likeNameWithStart;
	private String likeNameWithEnd;
	private String likeNameWithExact;
	private String likeNameWithAnywhere;
	private java.lang.String name;	
	private java.lang.String notEqName;	
	/** 邮箱 */
	private String likeEmailWithStart;
	private String likeEmailWithEnd;
	private String likeEmailWithExact;
	private String likeEmailWithAnywhere;
	private java.lang.String email;	
	private java.lang.String notEqEmail;	
	/** 手机号 */
	private String likePhoneWithStart;
	private String likePhoneWithEnd;
	private String likePhoneWithExact;
	private String likePhoneWithAnywhere;
	private java.lang.String phone;	
	private java.lang.String notEqPhone;	
	/** 性别 */
	private Integer sex;	
	private Integer notEqSex;	
	/** 年龄 */
	private Integer age;	
	private Integer notEqAge;	
	/** 用户类别[0:管理员,1:普通员工] */
	private Integer userType;	
	private Integer notEqUserType;	
	/** 组织id */
	private java.lang.Integer organizationId;	
	private java.lang.Integer notEqOrganizationId;	
	/** 是否锁定[0:正常,1:锁定] */
	private Integer locked;	
	private Integer notEqLocked;	
	/** 状态[0:失效,1:正常] */
	private Integer status;	
	private Integer notEqStatus;	
	/** 创建时间 */
	private java.time.LocalDateTime createTimeBegin;
	private java.time.LocalDateTime createTimeEnd;	
	private java.time.LocalDateTime createTime;	
	private java.time.LocalDateTime notEqCreateTime;	
	/** 更新时间 */
	private java.time.LocalDateTime updateTimeBegin;
	private java.time.LocalDateTime updateTimeEnd;	
	private java.time.LocalDateTime updateTime;	
	private java.time.LocalDateTime notEqUpdateTime;	
	
	/*********** 系统属性，自动赋值 *********/
	private boolean isId;
	private boolean isNotEqId;
	private MatchMode likeusername;
	private boolean isUsername;
	private boolean isNotEqUsername;
	private MatchMode likepassword;
	private boolean isPassword;
	private boolean isNotEqPassword;
	private MatchMode likename;
	private boolean isName;
	private boolean isNotEqName;
	private MatchMode likeemail;
	private boolean isEmail;
	private boolean isNotEqEmail;
	private MatchMode likephone;
	private boolean isPhone;
	private boolean isNotEqPhone;
	private boolean isSex;
	private boolean isNotEqSex;
	private boolean isAge;
	private boolean isNotEqAge;
	private boolean isUserType;
	private boolean isNotEqUserType;
	private boolean isOrganizationId;
	private boolean isNotEqOrganizationId;
	private boolean isLocked;
	private boolean isNotEqLocked;
	private boolean isStatus;
	private boolean isNotEqStatus;
	private boolean isCreateTimeBegin;
	private boolean isCreateTimeEnd;
	private boolean isCreateTime;
	private boolean isNotEqCreateTime;
	private boolean isUpdateTimeBegin;
	private boolean isUpdateTimeEnd;
	private boolean isUpdateTime;
	private boolean isNotEqUpdateTime;
	private java.lang.Integer ltCriterionId;
	public void setLtId(java.lang.Integer id){
		ltCriterionId = id;
	}
	public java.lang.Integer getLtId(){
		return ltCriterionId;
	}
	private java.lang.Integer leCriterionId;
	public void setLeId(java.lang.Integer id){
		leCriterionId = id;
	}
	public java.lang.Integer getLeId(){
		return leCriterionId;
	}
	private java.lang.Integer gtCriterionId;
	public void setGtId(java.lang.Integer id){
		gtCriterionId = id;
	}
	public java.lang.Integer getGtId(){
		return gtCriterionId;
	}
	private java.lang.Integer geCriterionId;
	public void setGeId(java.lang.Integer id){
		geCriterionId = id;
	}
	public java.lang.Integer getGeId(){
		return geCriterionId;
	}
	public java.lang.Integer getId() {
		return this.id;
	}
	
	public void setId(java.lang.Integer value) {		
		this.id = value;
		this.isId = true;
	}
	public boolean hasId() {
		return this.isId;
	}
	public java.lang.Integer getNotEqId() {
		return this.notEqId;
	}
	public void setNotEqId(java.lang.Integer id) {
		this.notEqId = id;
		this.isNotEqId = true;
	}
	public boolean hasNotEqId() {
		return this.isNotEqId;
	}
	// IN or notIN
	private List<java.lang.Integer>	inCriterionId;
	private List<java.lang.Integer>	notInCriterionId;
	public void setInId(boolean isIn,List<java.lang.Integer> ids){
		if(isIn){
			inCriterionId = ids;
		}else{
			notInCriterionId = ids;
		}
	}
	public List<java.lang.Integer> getInId() {
		return inCriterionId;
	}
	public List<java.lang.Integer> getNotInId() {
		return notInCriterionId;
	}
	
	//Null or NotNull
	private Boolean nullCriterionId;
	public void setNullId(boolean isNull){
			nullCriterionId = isNull;
	}
	public Boolean getNullId(){
		return nullCriterionId;
	} 
	
	public MatchMode getLikeUsername() {
		return this.likeusername;
	}
	public String getLikeUsernameWithStart() {
		return this.likeUsernameWithStart;
	}
	public void setLikeUsernameWithStart(String username) {	
		setUsername(username);
		setLikeUsername(MatchMode.START);
	}
	public String getLikeUsernameWithEnd() {
		return this.likeUsernameWithEnd;
	}
	public void setLikeUsernameWithEnd(String username) {	
		setUsername(username);
		setLikeUsername(MatchMode.END);
	}
	public String getLikeUsernameWithExact() {
		return this.likeUsernameWithExact;
	}
	public void setLikeUsernameWithExact(String username) {	
		setUsername(username);
		setLikeUsername(MatchMode.EXACT);
	}
	public String getLikeUsernameWithAnywhere() {
		return this.likeUsernameWithAnywhere;
	}
	public void setLikeUsernameWithAnywhere(String username) {	
		setUsername(username);
		setLikeUsername(MatchMode.ANYWHERE);
	}
	private void setLikeUsername(MatchMode matchMode) {		
		this.likeusername = matchMode;
	}
	public java.lang.String getUsername() {
		return this.username;
	}
	
	public void setUsername(java.lang.String value) {		
		this.username = value;
		this.isUsername = true;
	}
	public boolean hasUsername() {
		return this.isUsername;
	}
	public java.lang.String getNotEqUsername() {
		return this.notEqUsername;
	}
	public void setNotEqUsername(java.lang.String username) {
		this.notEqUsername = username;
		this.isNotEqUsername = true;
	}
	public boolean hasNotEqUsername() {
		return this.isNotEqUsername;
	}
	// IN or notIN
	private List<java.lang.String>	inCriterionUsername;
	private List<java.lang.String>	notInCriterionUsername;
	public void setInUsername(boolean isIn,List<java.lang.String> usernames){
		if(isIn){
			inCriterionUsername = usernames;
		}else{
			notInCriterionUsername = usernames;
		}
	}
	public List<java.lang.String> getInUsername() {
		return inCriterionUsername;
	}
	public List<java.lang.String> getNotInUsername() {
		return notInCriterionUsername;
	}
	
	//Null or NotNull
	private Boolean nullCriterionUsername;
	public void setNullUsername(boolean isNull){
			nullCriterionUsername = isNull;
	}
	public Boolean getNullUsername(){
		return nullCriterionUsername;
	} 
	
	public MatchMode getLikePassword() {
		return this.likepassword;
	}
	public String getLikePasswordWithStart() {
		return this.likePasswordWithStart;
	}
	public void setLikePasswordWithStart(String password) {	
		setPassword(password);
		setLikePassword(MatchMode.START);
	}
	public String getLikePasswordWithEnd() {
		return this.likePasswordWithEnd;
	}
	public void setLikePasswordWithEnd(String password) {	
		setPassword(password);
		setLikePassword(MatchMode.END);
	}
	public String getLikePasswordWithExact() {
		return this.likePasswordWithExact;
	}
	public void setLikePasswordWithExact(String password) {	
		setPassword(password);
		setLikePassword(MatchMode.EXACT);
	}
	public String getLikePasswordWithAnywhere() {
		return this.likePasswordWithAnywhere;
	}
	public void setLikePasswordWithAnywhere(String password) {	
		setPassword(password);
		setLikePassword(MatchMode.ANYWHERE);
	}
	private void setLikePassword(MatchMode matchMode) {		
		this.likepassword = matchMode;
	}
	public java.lang.String getPassword() {
		return this.password;
	}
	
	public void setPassword(java.lang.String value) {		
		this.password = value;
		this.isPassword = true;
	}
	public boolean hasPassword() {
		return this.isPassword;
	}
	public java.lang.String getNotEqPassword() {
		return this.notEqPassword;
	}
	public void setNotEqPassword(java.lang.String password) {
		this.notEqPassword = password;
		this.isNotEqPassword = true;
	}
	public boolean hasNotEqPassword() {
		return this.isNotEqPassword;
	}
	// IN or notIN
	private List<java.lang.String>	inCriterionPassword;
	private List<java.lang.String>	notInCriterionPassword;
	public void setInPassword(boolean isIn,List<java.lang.String> passwords){
		if(isIn){
			inCriterionPassword = passwords;
		}else{
			notInCriterionPassword = passwords;
		}
	}
	public List<java.lang.String> getInPassword() {
		return inCriterionPassword;
	}
	public List<java.lang.String> getNotInPassword() {
		return notInCriterionPassword;
	}
	
	//Null or NotNull
	private Boolean nullCriterionPassword;
	public void setNullPassword(boolean isNull){
			nullCriterionPassword = isNull;
	}
	public Boolean getNullPassword(){
		return nullCriterionPassword;
	} 
	
	public MatchMode getLikeName() {
		return this.likename;
	}
	public String getLikeNameWithStart() {
		return this.likeNameWithStart;
	}
	public void setLikeNameWithStart(String name) {	
		setName(name);
		setLikeName(MatchMode.START);
	}
	public String getLikeNameWithEnd() {
		return this.likeNameWithEnd;
	}
	public void setLikeNameWithEnd(String name) {	
		setName(name);
		setLikeName(MatchMode.END);
	}
	public String getLikeNameWithExact() {
		return this.likeNameWithExact;
	}
	public void setLikeNameWithExact(String name) {	
		setName(name);
		setLikeName(MatchMode.EXACT);
	}
	public String getLikeNameWithAnywhere() {
		return this.likeNameWithAnywhere;
	}
	public void setLikeNameWithAnywhere(String name) {	
		setName(name);
		setLikeName(MatchMode.ANYWHERE);
	}
	private void setLikeName(MatchMode matchMode) {		
		this.likename = matchMode;
	}
	public java.lang.String getName() {
		return this.name;
	}
	
	public void setName(java.lang.String value) {		
		this.name = value;
		this.isName = true;
	}
	public boolean hasName() {
		return this.isName;
	}
	public java.lang.String getNotEqName() {
		return this.notEqName;
	}
	public void setNotEqName(java.lang.String name) {
		this.notEqName = name;
		this.isNotEqName = true;
	}
	public boolean hasNotEqName() {
		return this.isNotEqName;
	}
	// IN or notIN
	private List<java.lang.String>	inCriterionName;
	private List<java.lang.String>	notInCriterionName;
	public void setInName(boolean isIn,List<java.lang.String> names){
		if(isIn){
			inCriterionName = names;
		}else{
			notInCriterionName = names;
		}
	}
	public List<java.lang.String> getInName() {
		return inCriterionName;
	}
	public List<java.lang.String> getNotInName() {
		return notInCriterionName;
	}
	
	//Null or NotNull
	private Boolean nullCriterionName;
	public void setNullName(boolean isNull){
			nullCriterionName = isNull;
	}
	public Boolean getNullName(){
		return nullCriterionName;
	} 
	
	public MatchMode getLikeEmail() {
		return this.likeemail;
	}
	public String getLikeEmailWithStart() {
		return this.likeEmailWithStart;
	}
	public void setLikeEmailWithStart(String email) {	
		setEmail(email);
		setLikeEmail(MatchMode.START);
	}
	public String getLikeEmailWithEnd() {
		return this.likeEmailWithEnd;
	}
	public void setLikeEmailWithEnd(String email) {	
		setEmail(email);
		setLikeEmail(MatchMode.END);
	}
	public String getLikeEmailWithExact() {
		return this.likeEmailWithExact;
	}
	public void setLikeEmailWithExact(String email) {	
		setEmail(email);
		setLikeEmail(MatchMode.EXACT);
	}
	public String getLikeEmailWithAnywhere() {
		return this.likeEmailWithAnywhere;
	}
	public void setLikeEmailWithAnywhere(String email) {	
		setEmail(email);
		setLikeEmail(MatchMode.ANYWHERE);
	}
	private void setLikeEmail(MatchMode matchMode) {		
		this.likeemail = matchMode;
	}
	public java.lang.String getEmail() {
		return this.email;
	}
	
	public void setEmail(java.lang.String value) {		
		this.email = value;
		this.isEmail = true;
	}
	public boolean hasEmail() {
		return this.isEmail;
	}
	public java.lang.String getNotEqEmail() {
		return this.notEqEmail;
	}
	public void setNotEqEmail(java.lang.String email) {
		this.notEqEmail = email;
		this.isNotEqEmail = true;
	}
	public boolean hasNotEqEmail() {
		return this.isNotEqEmail;
	}
	// IN or notIN
	private List<java.lang.String>	inCriterionEmail;
	private List<java.lang.String>	notInCriterionEmail;
	public void setInEmail(boolean isIn,List<java.lang.String> emails){
		if(isIn){
			inCriterionEmail = emails;
		}else{
			notInCriterionEmail = emails;
		}
	}
	public List<java.lang.String> getInEmail() {
		return inCriterionEmail;
	}
	public List<java.lang.String> getNotInEmail() {
		return notInCriterionEmail;
	}
	
	//Null or NotNull
	private Boolean nullCriterionEmail;
	public void setNullEmail(boolean isNull){
			nullCriterionEmail = isNull;
	}
	public Boolean getNullEmail(){
		return nullCriterionEmail;
	} 
	
	public MatchMode getLikePhone() {
		return this.likephone;
	}
	public String getLikePhoneWithStart() {
		return this.likePhoneWithStart;
	}
	public void setLikePhoneWithStart(String phone) {	
		setPhone(phone);
		setLikePhone(MatchMode.START);
	}
	public String getLikePhoneWithEnd() {
		return this.likePhoneWithEnd;
	}
	public void setLikePhoneWithEnd(String phone) {	
		setPhone(phone);
		setLikePhone(MatchMode.END);
	}
	public String getLikePhoneWithExact() {
		return this.likePhoneWithExact;
	}
	public void setLikePhoneWithExact(String phone) {	
		setPhone(phone);
		setLikePhone(MatchMode.EXACT);
	}
	public String getLikePhoneWithAnywhere() {
		return this.likePhoneWithAnywhere;
	}
	public void setLikePhoneWithAnywhere(String phone) {	
		setPhone(phone);
		setLikePhone(MatchMode.ANYWHERE);
	}
	private void setLikePhone(MatchMode matchMode) {		
		this.likephone = matchMode;
	}
	public java.lang.String getPhone() {
		return this.phone;
	}
	
	public void setPhone(java.lang.String value) {		
		this.phone = value;
		this.isPhone = true;
	}
	public boolean hasPhone() {
		return this.isPhone;
	}
	public java.lang.String getNotEqPhone() {
		return this.notEqPhone;
	}
	public void setNotEqPhone(java.lang.String phone) {
		this.notEqPhone = phone;
		this.isNotEqPhone = true;
	}
	public boolean hasNotEqPhone() {
		return this.isNotEqPhone;
	}
	// IN or notIN
	private List<java.lang.String>	inCriterionPhone;
	private List<java.lang.String>	notInCriterionPhone;
	public void setInPhone(boolean isIn,List<java.lang.String> phones){
		if(isIn){
			inCriterionPhone = phones;
		}else{
			notInCriterionPhone = phones;
		}
	}
	public List<java.lang.String> getInPhone() {
		return inCriterionPhone;
	}
	public List<java.lang.String> getNotInPhone() {
		return notInCriterionPhone;
	}
	
	//Null or NotNull
	private Boolean nullCriterionPhone;
	public void setNullPhone(boolean isNull){
			nullCriterionPhone = isNull;
	}
	public Boolean getNullPhone(){
		return nullCriterionPhone;
	} 
	
	public Integer getSex() {
		return this.sex;
	}
	
	public void setSex(Integer value) {		
		this.sex = value;
		this.isSex = true;
	}
	public boolean hasSex() {
		return this.isSex;
	}
	public Integer getNotEqSex() {
		return this.notEqSex;
	}
	public void setNotEqSex(Integer sex) {
		this.notEqSex = sex;
		this.isNotEqSex = true;
	}
	public boolean hasNotEqSex() {
		return this.isNotEqSex;
	}
	// IN or notIN
	private List<Integer>	inCriterionSex;
	private List<Integer>	notInCriterionSex;
	public void setInSex(boolean isIn,List<Integer> sexs){
		if(isIn){
			inCriterionSex = sexs;
		}else{
			notInCriterionSex = sexs;
		}
	}
	public List<Integer> getInSex() {
		return inCriterionSex;
	}
	public List<Integer> getNotInSex() {
		return notInCriterionSex;
	}
	
	//Null or NotNull
	private Boolean nullCriterionSex;
	public void setNullSex(boolean isNull){
			nullCriterionSex = isNull;
	}
	public Boolean getNullSex(){
		return nullCriterionSex;
	} 
	
	public Integer getAge() {
		return this.age;
	}
	
	public void setAge(Integer value) {		
		this.age = value;
		this.isAge = true;
	}
	public boolean hasAge() {
		return this.isAge;
	}
	public Integer getNotEqAge() {
		return this.notEqAge;
	}
	public void setNotEqAge(Integer age) {
		this.notEqAge = age;
		this.isNotEqAge = true;
	}
	public boolean hasNotEqAge() {
		return this.isNotEqAge;
	}
	// IN or notIN
	private List<Integer>	inCriterionAge;
	private List<Integer>	notInCriterionAge;
	public void setInAge(boolean isIn,List<Integer> ages){
		if(isIn){
			inCriterionAge = ages;
		}else{
			notInCriterionAge = ages;
		}
	}
	public List<Integer> getInAge() {
		return inCriterionAge;
	}
	public List<Integer> getNotInAge() {
		return notInCriterionAge;
	}
	
	//Null or NotNull
	private Boolean nullCriterionAge;
	public void setNullAge(boolean isNull){
			nullCriterionAge = isNull;
	}
	public Boolean getNullAge(){
		return nullCriterionAge;
	} 
	
	public Integer getUserType() {
		return this.userType;
	}
	
	public void setUserType(Integer value) {		
		this.userType = value;
		this.isUserType = true;
	}
	public boolean hasUserType() {
		return this.isUserType;
	}
	public Integer getNotEqUserType() {
		return this.notEqUserType;
	}
	public void setNotEqUserType(Integer userType) {
		this.notEqUserType = userType;
		this.isNotEqUserType = true;
	}
	public boolean hasNotEqUserType() {
		return this.isNotEqUserType;
	}
	// IN or notIN
	private List<Integer>	inCriterionUserType;
	private List<Integer>	notInCriterionUserType;
	public void setInUserType(boolean isIn,List<Integer> userTypes){
		if(isIn){
			inCriterionUserType = userTypes;
		}else{
			notInCriterionUserType = userTypes;
		}
	}
	public List<Integer> getInUserType() {
		return inCriterionUserType;
	}
	public List<Integer> getNotInUserType() {
		return notInCriterionUserType;
	}
	
	//Null or NotNull
	private Boolean nullCriterionUserType;
	public void setNullUserType(boolean isNull){
			nullCriterionUserType = isNull;
	}
	public Boolean getNullUserType(){
		return nullCriterionUserType;
	} 
	
	private java.lang.Integer ltCriterionOrganizationId;
	public void setLtOrganizationId(java.lang.Integer organizationId){
		ltCriterionOrganizationId = organizationId;
	}
	public java.lang.Integer getLtOrganizationId(){
		return ltCriterionOrganizationId;
	}
	private java.lang.Integer leCriterionOrganizationId;
	public void setLeOrganizationId(java.lang.Integer organizationId){
		leCriterionOrganizationId = organizationId;
	}
	public java.lang.Integer getLeOrganizationId(){
		return leCriterionOrganizationId;
	}
	private java.lang.Integer gtCriterionOrganizationId;
	public void setGtOrganizationId(java.lang.Integer organizationId){
		gtCriterionOrganizationId = organizationId;
	}
	public java.lang.Integer getGtOrganizationId(){
		return gtCriterionOrganizationId;
	}
	private java.lang.Integer geCriterionOrganizationId;
	public void setGeOrganizationId(java.lang.Integer organizationId){
		geCriterionOrganizationId = organizationId;
	}
	public java.lang.Integer getGeOrganizationId(){
		return geCriterionOrganizationId;
	}
	public java.lang.Integer getOrganizationId() {
		return this.organizationId;
	}
	
	public void setOrganizationId(java.lang.Integer value) {		
		this.organizationId = value;
		this.isOrganizationId = true;
	}
	public boolean hasOrganizationId() {
		return this.isOrganizationId;
	}
	public java.lang.Integer getNotEqOrganizationId() {
		return this.notEqOrganizationId;
	}
	public void setNotEqOrganizationId(java.lang.Integer organizationId) {
		this.notEqOrganizationId = organizationId;
		this.isNotEqOrganizationId = true;
	}
	public boolean hasNotEqOrganizationId() {
		return this.isNotEqOrganizationId;
	}
	// IN or notIN
	private List<java.lang.Integer>	inCriterionOrganizationId;
	private List<java.lang.Integer>	notInCriterionOrganizationId;
	public void setInOrganizationId(boolean isIn,List<java.lang.Integer> organizationIds){
		if(isIn){
			inCriterionOrganizationId = organizationIds;
		}else{
			notInCriterionOrganizationId = organizationIds;
		}
	}
	public List<java.lang.Integer> getInOrganizationId() {
		return inCriterionOrganizationId;
	}
	public List<java.lang.Integer> getNotInOrganizationId() {
		return notInCriterionOrganizationId;
	}
	
	//Null or NotNull
	private Boolean nullCriterionOrganizationId;
	public void setNullOrganizationId(boolean isNull){
			nullCriterionOrganizationId = isNull;
	}
	public Boolean getNullOrganizationId(){
		return nullCriterionOrganizationId;
	} 
	
	public Integer getLocked() {
		return this.locked;
	}
	
	public void setLocked(Integer value) {		
		this.locked = value;
		this.isLocked = true;
	}
	public boolean hasLocked() {
		return this.isLocked;
	}
	public Integer getNotEqLocked() {
		return this.notEqLocked;
	}
	public void setNotEqLocked(Integer locked) {
		this.notEqLocked = locked;
		this.isNotEqLocked = true;
	}
	public boolean hasNotEqLocked() {
		return this.isNotEqLocked;
	}
	// IN or notIN
	private List<Integer>	inCriterionLocked;
	private List<Integer>	notInCriterionLocked;
	public void setInLocked(boolean isIn,List<Integer> lockeds){
		if(isIn){
			inCriterionLocked = lockeds;
		}else{
			notInCriterionLocked = lockeds;
		}
	}
	public List<Integer> getInLocked() {
		return inCriterionLocked;
	}
	public List<Integer> getNotInLocked() {
		return notInCriterionLocked;
	}
	
	//Null or NotNull
	private Boolean nullCriterionLocked;
	public void setNullLocked(boolean isNull){
			nullCriterionLocked = isNull;
	}
	public Boolean getNullLocked(){
		return nullCriterionLocked;
	} 
	
	public Integer getStatus() {
		return this.status;
	}
	
	public void setStatus(Integer value) {		
		this.status = value;
		this.isStatus = true;
	}
	public boolean hasStatus() {
		return this.isStatus;
	}
	public Integer getNotEqStatus() {
		return this.notEqStatus;
	}
	public void setNotEqStatus(Integer status) {
		this.notEqStatus = status;
		this.isNotEqStatus = true;
	}
	public boolean hasNotEqStatus() {
		return this.isNotEqStatus;
	}
	// IN or notIN
	private List<Integer>	inCriterionStatus;
	private List<Integer>	notInCriterionStatus;
	public void setInStatus(boolean isIn,List<Integer> statuss){
		if(isIn){
			inCriterionStatus = statuss;
		}else{
			notInCriterionStatus = statuss;
		}
	}
	public List<Integer> getInStatus() {
		return inCriterionStatus;
	}
	public List<Integer> getNotInStatus() {
		return notInCriterionStatus;
	}
	
	//Null or NotNull
	private Boolean nullCriterionStatus;
	public void setNullStatus(boolean isNull){
			nullCriterionStatus = isNull;
	}
	public Boolean getNullStatus(){
		return nullCriterionStatus;
	} 
	
	public java.time.LocalDateTime getCreateTimeBegin() {
		return this.createTimeBegin;
	}
	
	public void setCreateTimeBegin(java.time.LocalDateTime value) {
		this.createTimeBegin = value;
		this.isCreateTimeBegin = true;
	}	
	
	public java.time.LocalDateTime getCreateTimeEnd() {
		return this.createTimeEnd;
	}
	
	public void setCreateTimeEnd(java.time.LocalDateTime value) {
		this.createTimeEnd = value;
		this.isCreateTimeEnd = true;
	}
	public boolean hasCreateTimeBegin() {
		return this.isCreateTimeBegin;
	}
	public boolean hasCreateTimeEnd() {
		return this.isCreateTimeEnd;
	}	
	public java.time.LocalDateTime getCreateTime() {
		return this.createTime;
	}
	
	public void setCreateTime(java.time.LocalDateTime value) {		
		this.createTime = value;
		this.isCreateTime = true;
	}
	public boolean hasCreateTime() {
		return this.isCreateTime;
	}
	public java.time.LocalDateTime getNotEqCreateTime() {
		return this.notEqCreateTime;
	}
	public void setNotEqCreateTime(java.time.LocalDateTime createTime) {
		this.notEqCreateTime = createTime;
		this.isNotEqCreateTime = true;
	}
	public boolean hasNotEqCreateTime() {
		return this.isNotEqCreateTime;
	}
	// IN or notIN
	private List<java.time.LocalDateTime>	inCriterionCreateTime;
	private List<java.time.LocalDateTime>	notInCriterionCreateTime;
	public void setInCreateTime(boolean isIn,List<java.time.LocalDateTime> createTimes){
		if(isIn){
			inCriterionCreateTime = createTimes;
		}else{
			notInCriterionCreateTime = createTimes;
		}
	}
	public List<java.time.LocalDateTime> getInCreateTime() {
		return inCriterionCreateTime;
	}
	public List<java.time.LocalDateTime> getNotInCreateTime() {
		return notInCriterionCreateTime;
	}
	
	//Null or NotNull
	private Boolean nullCriterionCreateTime;
	public void setNullCreateTime(boolean isNull){
			nullCriterionCreateTime = isNull;
	}
	public Boolean getNullCreateTime(){
		return nullCriterionCreateTime;
	} 
	
	public java.time.LocalDateTime getUpdateTimeBegin() {
		return this.updateTimeBegin;
	}
	
	public void setUpdateTimeBegin(java.time.LocalDateTime value) {
		this.updateTimeBegin = value;
		this.isUpdateTimeBegin = true;
	}	
	
	public java.time.LocalDateTime getUpdateTimeEnd() {
		return this.updateTimeEnd;
	}
	
	public void setUpdateTimeEnd(java.time.LocalDateTime value) {
		this.updateTimeEnd = value;
		this.isUpdateTimeEnd = true;
	}
	public boolean hasUpdateTimeBegin() {
		return this.isUpdateTimeBegin;
	}
	public boolean hasUpdateTimeEnd() {
		return this.isUpdateTimeEnd;
	}	
	public java.time.LocalDateTime getUpdateTime() {
		return this.updateTime;
	}
	
	public void setUpdateTime(java.time.LocalDateTime value) {		
		this.updateTime = value;
		this.isUpdateTime = true;
	}
	public boolean hasUpdateTime() {
		return this.isUpdateTime;
	}
	public java.time.LocalDateTime getNotEqUpdateTime() {
		return this.notEqUpdateTime;
	}
	public void setNotEqUpdateTime(java.time.LocalDateTime updateTime) {
		this.notEqUpdateTime = updateTime;
		this.isNotEqUpdateTime = true;
	}
	public boolean hasNotEqUpdateTime() {
		return this.isNotEqUpdateTime;
	}
	// IN or notIN
	private List<java.time.LocalDateTime>	inCriterionUpdateTime;
	private List<java.time.LocalDateTime>	notInCriterionUpdateTime;
	public void setInUpdateTime(boolean isIn,List<java.time.LocalDateTime> updateTimes){
		if(isIn){
			inCriterionUpdateTime = updateTimes;
		}else{
			notInCriterionUpdateTime = updateTimes;
		}
	}
	public List<java.time.LocalDateTime> getInUpdateTime() {
		return inCriterionUpdateTime;
	}
	public List<java.time.LocalDateTime> getNotInUpdateTime() {
		return notInCriterionUpdateTime;
	}
	
	//Null or NotNull
	private Boolean nullCriterionUpdateTime;
	public void setNullUpdateTime(boolean isNull){
			nullCriterionUpdateTime = isNull;
	}
	public Boolean getNullUpdateTime(){
		return nullCriterionUpdateTime;
	} 
	
	private List<String> listOrderAsc = new ArrayList<>();
	private List<String> listOrderDesc = new ArrayList<>();

	public void setOrderAsc(String fdName) {
		listOrderAsc.add(fdName);
	}

	public void setOrderDec(String fdName) {
		listOrderDesc.add(fdName);
	}

	public List<String> getOrderAscList() {
		return listOrderAsc;
	}

	public List<String> getOrderDecList() {
		return listOrderDesc;
	}
	
	
	/**
	 * 获取查询条件
	 */
	public Specification<Admin> createSpecification() {
		Specification<Admin> example = (root, query, criteriaBuilder) -> {
			List<Order> orders = new ArrayList<>();
			for (String asc : this.getOrderAscList()) {
				orders.add(criteriaBuilder.asc(root.get(asc)));
			}
			for (String desc : this.getOrderDecList()) {
				orders.add(criteriaBuilder.desc(root.get(desc)));
			}
			query.orderBy(orders);
			List<Predicate> predicates = createQuery(root, this, criteriaBuilder);
			hookQuery(root, criteriaBuilder,predicates);
			return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
		};
		return example;
	}
	/**
	 * <p>
	 * <p>自定义的方法时候实现此方法即可(内部类方式使用即可)
	 * <p>使用方法: predicates.add(criteriaBuilder.equal(root.get("biaoqian").as(String.class), "value"));
	 * @param root
	 * @param query
	 * @param criteriaBuilder
	 * @param predicates
	 */
	public void hookQuery(Root<Admin> root, CriteriaBuilder criteriaBuilder,List<Predicate> predicates) {}
	/**
	 * 组装query对象
	 * 
	 * @param root
	 * @param AdminQuery
	 * @param criteriaBuilder
	 * @return
	 */
	private List<Predicate> createQuery(Root<Admin> root, AdminQuery query, CriteriaBuilder criteriaBuilder) {
		List<Predicate> predicates = new ArrayList<Predicate>();
		/**
		 * idExpression
		 */
		Expression<java.lang.Integer> idExpression = root.get(Admin.PROP_ID).as(java.lang.Integer.class);
		if (query.hasId()) {
			java.lang.Integer value = query.getId();
			if( value != null){
				predicates.add(criteriaBuilder.equal(idExpression, value));					
			}
		}
		if (query.hasNotEqId()) {
			java.lang.Integer value = query.getNotEqId();
			predicates.add(criteriaBuilder.notEqual(idExpression, value));
		}
		
		if(query.getLeId()!=null){
			predicates.add(criteriaBuilder.le(idExpression, query.getLeId()));
		}
		if(query.getGeId()!=null){
			predicates.add(criteriaBuilder.ge(idExpression, query.getGeId()));
		}
		if(query.getLtId()!=null){
			predicates.add(criteriaBuilder.lt(idExpression, query.getLtId()));
		}
		if(query.getGtId()!=null){
			predicates.add(criteriaBuilder.gt(idExpression, query.getGtId()));
		}
		
		if (query.getInId() != null) {
			predicates.add(idExpression.in(query.getInId()));
		}
		if (query.getNotInId() != null) {
			predicates.add(criteriaBuilder.not(idExpression.in(query.getInId())));
		}
		if (query.getNullId() != null) {
			if (query.getNullId()) {
				predicates.add(criteriaBuilder.isNull(idExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(idExpression));
			}
		}
		/**
		 * usernameExpression
		 */
		Expression<java.lang.String> usernameExpression = root.get(Admin.PROP_USERNAME).as(java.lang.String.class);
		if (query.hasUsername()) {
			java.lang.String value = query.getUsername();
			if (query.getLikeUsername() != null) {
				predicates.add(criteriaBuilder.like(usernameExpression, query.getLikeUsername().toMatchString(value)));
			} else {
				predicates.add(criteriaBuilder.equal(usernameExpression, value));
			}
		}
		if (query.hasNotEqUsername()) {
			java.lang.String value = query.getNotEqUsername();
			predicates.add(criteriaBuilder.notEqual(usernameExpression, value));
		}
		
		if (query.getInUsername() != null) {
			predicates.add(usernameExpression.in(query.getInUsername()));
		}
		if (query.getNotInUsername() != null) {
			predicates.add(criteriaBuilder.not(usernameExpression.in(query.getInUsername())));
		}
		if (query.getNullUsername() != null) {
			if (query.getNullUsername()) {
				predicates.add(criteriaBuilder.isNull(usernameExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(usernameExpression));
			}
		}
		/**
		 * passwordExpression
		 */
		Expression<java.lang.String> passwordExpression = root.get(Admin.PROP_PASSWORD).as(java.lang.String.class);
		if (query.hasPassword()) {
			java.lang.String value = query.getPassword();
			if (query.getLikePassword() != null) {
				predicates.add(criteriaBuilder.like(passwordExpression, query.getLikePassword().toMatchString(value)));
			} else {
				predicates.add(criteriaBuilder.equal(passwordExpression, value));
			}
		}
		if (query.hasNotEqPassword()) {
			java.lang.String value = query.getNotEqPassword();
			predicates.add(criteriaBuilder.notEqual(passwordExpression, value));
		}
		
		if (query.getInPassword() != null) {
			predicates.add(passwordExpression.in(query.getInPassword()));
		}
		if (query.getNotInPassword() != null) {
			predicates.add(criteriaBuilder.not(passwordExpression.in(query.getInPassword())));
		}
		if (query.getNullPassword() != null) {
			if (query.getNullPassword()) {
				predicates.add(criteriaBuilder.isNull(passwordExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(passwordExpression));
			}
		}
		/**
		 * nameExpression
		 */
		Expression<java.lang.String> nameExpression = root.get(Admin.PROP_NAME).as(java.lang.String.class);
		if (query.hasName()) {
			java.lang.String value = query.getName();
			if (query.getLikeName() != null) {
				predicates.add(criteriaBuilder.like(nameExpression, query.getLikeName().toMatchString(value)));
			} else {
				predicates.add(criteriaBuilder.equal(nameExpression, value));
			}
		}
		if (query.hasNotEqName()) {
			java.lang.String value = query.getNotEqName();
			predicates.add(criteriaBuilder.notEqual(nameExpression, value));
		}
		
		if (query.getInName() != null) {
			predicates.add(nameExpression.in(query.getInName()));
		}
		if (query.getNotInName() != null) {
			predicates.add(criteriaBuilder.not(nameExpression.in(query.getInName())));
		}
		if (query.getNullName() != null) {
			if (query.getNullName()) {
				predicates.add(criteriaBuilder.isNull(nameExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(nameExpression));
			}
		}
		/**
		 * emailExpression
		 */
		Expression<java.lang.String> emailExpression = root.get(Admin.PROP_EMAIL).as(java.lang.String.class);
		if (query.hasEmail()) {
			java.lang.String value = query.getEmail();
			if (query.getLikeEmail() != null) {
				predicates.add(criteriaBuilder.like(emailExpression, query.getLikeEmail().toMatchString(value)));
			} else {
				predicates.add(criteriaBuilder.equal(emailExpression, value));
			}
		}
		if (query.hasNotEqEmail()) {
			java.lang.String value = query.getNotEqEmail();
			predicates.add(criteriaBuilder.notEqual(emailExpression, value));
		}
		
		if (query.getInEmail() != null) {
			predicates.add(emailExpression.in(query.getInEmail()));
		}
		if (query.getNotInEmail() != null) {
			predicates.add(criteriaBuilder.not(emailExpression.in(query.getInEmail())));
		}
		if (query.getNullEmail() != null) {
			if (query.getNullEmail()) {
				predicates.add(criteriaBuilder.isNull(emailExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(emailExpression));
			}
		}
		/**
		 * phoneExpression
		 */
		Expression<java.lang.String> phoneExpression = root.get(Admin.PROP_PHONE).as(java.lang.String.class);
		if (query.hasPhone()) {
			java.lang.String value = query.getPhone();
			if (query.getLikePhone() != null) {
				predicates.add(criteriaBuilder.like(phoneExpression, query.getLikePhone().toMatchString(value)));
			} else {
				predicates.add(criteriaBuilder.equal(phoneExpression, value));
			}
		}
		if (query.hasNotEqPhone()) {
			java.lang.String value = query.getNotEqPhone();
			predicates.add(criteriaBuilder.notEqual(phoneExpression, value));
		}
		
		if (query.getInPhone() != null) {
			predicates.add(phoneExpression.in(query.getInPhone()));
		}
		if (query.getNotInPhone() != null) {
			predicates.add(criteriaBuilder.not(phoneExpression.in(query.getInPhone())));
		}
		if (query.getNullPhone() != null) {
			if (query.getNullPhone()) {
				predicates.add(criteriaBuilder.isNull(phoneExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(phoneExpression));
			}
		}
		/**
		 * sexExpression
		 */
		Expression<Integer> sexExpression = root.get(Admin.PROP_SEX).as(Integer.class);
		if (query.hasSex()) {
			Integer value = query.getSex();
			if( value != null){
				predicates.add(criteriaBuilder.equal(sexExpression, value));					
			}
		}
		if (query.hasNotEqSex()) {
			Integer value = query.getNotEqSex();
			predicates.add(criteriaBuilder.notEqual(sexExpression, value));
		}
		
		if (query.getInSex() != null) {
			predicates.add(sexExpression.in(query.getInSex()));
		}
		if (query.getNotInSex() != null) {
			predicates.add(criteriaBuilder.not(sexExpression.in(query.getInSex())));
		}
		if (query.getNullSex() != null) {
			if (query.getNullSex()) {
				predicates.add(criteriaBuilder.isNull(sexExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(sexExpression));
			}
		}
		/**
		 * ageExpression
		 */
		Expression<Integer> ageExpression = root.get(Admin.PROP_AGE).as(Integer.class);
		if (query.hasAge()) {
			Integer value = query.getAge();
			if( value != null){
				predicates.add(criteriaBuilder.equal(ageExpression, value));					
			}
		}
		if (query.hasNotEqAge()) {
			Integer value = query.getNotEqAge();
			predicates.add(criteriaBuilder.notEqual(ageExpression, value));
		}
		
		if (query.getInAge() != null) {
			predicates.add(ageExpression.in(query.getInAge()));
		}
		if (query.getNotInAge() != null) {
			predicates.add(criteriaBuilder.not(ageExpression.in(query.getInAge())));
		}
		if (query.getNullAge() != null) {
			if (query.getNullAge()) {
				predicates.add(criteriaBuilder.isNull(ageExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(ageExpression));
			}
		}
		/**
		 * userTypeExpression
		 */
		Expression<Integer> userTypeExpression = root.get(Admin.PROP_USER_TYPE).as(Integer.class);
		if (query.hasUserType()) {
			Integer value = query.getUserType();
			if( value != null){
				predicates.add(criteriaBuilder.equal(userTypeExpression, value));					
			}
		}
		if (query.hasNotEqUserType()) {
			Integer value = query.getNotEqUserType();
			predicates.add(criteriaBuilder.notEqual(userTypeExpression, value));
		}
		
		if (query.getInUserType() != null) {
			predicates.add(userTypeExpression.in(query.getInUserType()));
		}
		if (query.getNotInUserType() != null) {
			predicates.add(criteriaBuilder.not(userTypeExpression.in(query.getInUserType())));
		}
		if (query.getNullUserType() != null) {
			if (query.getNullUserType()) {
				predicates.add(criteriaBuilder.isNull(userTypeExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(userTypeExpression));
			}
		}
		/**
		 * organizationIdExpression
		 */
		Expression<java.lang.Integer> organizationIdExpression = root.get(Admin.PROP_ORGANIZATION_ID).as(java.lang.Integer.class);
		if (query.hasOrganizationId()) {
			java.lang.Integer value = query.getOrganizationId();
			if( value != null){
				predicates.add(criteriaBuilder.equal(organizationIdExpression, value));					
			}
		}
		if (query.hasNotEqOrganizationId()) {
			java.lang.Integer value = query.getNotEqOrganizationId();
			predicates.add(criteriaBuilder.notEqual(organizationIdExpression, value));
		}
		
		if(query.getLeOrganizationId()!=null){
			predicates.add(criteriaBuilder.le(organizationIdExpression, query.getLeOrganizationId()));
		}
		if(query.getGeOrganizationId()!=null){
			predicates.add(criteriaBuilder.ge(organizationIdExpression, query.getGeOrganizationId()));
		}
		if(query.getLtOrganizationId()!=null){
			predicates.add(criteriaBuilder.lt(organizationIdExpression, query.getLtOrganizationId()));
		}
		if(query.getGtOrganizationId()!=null){
			predicates.add(criteriaBuilder.gt(organizationIdExpression, query.getGtOrganizationId()));
		}
		
		if (query.getInOrganizationId() != null) {
			predicates.add(organizationIdExpression.in(query.getInOrganizationId()));
		}
		if (query.getNotInOrganizationId() != null) {
			predicates.add(criteriaBuilder.not(organizationIdExpression.in(query.getInOrganizationId())));
		}
		if (query.getNullOrganizationId() != null) {
			if (query.getNullOrganizationId()) {
				predicates.add(criteriaBuilder.isNull(organizationIdExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(organizationIdExpression));
			}
		}
		/**
		 * lockedExpression
		 */
		Expression<Integer> lockedExpression = root.get(Admin.PROP_LOCKED).as(Integer.class);
		if (query.hasLocked()) {
			Integer value = query.getLocked();
			if( value != null){
				predicates.add(criteriaBuilder.equal(lockedExpression, value));					
			}
		}
		if (query.hasNotEqLocked()) {
			Integer value = query.getNotEqLocked();
			predicates.add(criteriaBuilder.notEqual(lockedExpression, value));
		}
		
		if (query.getInLocked() != null) {
			predicates.add(lockedExpression.in(query.getInLocked()));
		}
		if (query.getNotInLocked() != null) {
			predicates.add(criteriaBuilder.not(lockedExpression.in(query.getInLocked())));
		}
		if (query.getNullLocked() != null) {
			if (query.getNullLocked()) {
				predicates.add(criteriaBuilder.isNull(lockedExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(lockedExpression));
			}
		}
		/**
		 * statusExpression
		 */
		Expression<Integer> statusExpression = root.get(Admin.PROP_STATUS).as(Integer.class);
		if (query.hasStatus()) {
			Integer value = query.getStatus();
			if( value != null){
				predicates.add(criteriaBuilder.equal(statusExpression, value));					
			}
		}
		if (query.hasNotEqStatus()) {
			Integer value = query.getNotEqStatus();
			predicates.add(criteriaBuilder.notEqual(statusExpression, value));
		}
		
		if (query.getInStatus() != null) {
			predicates.add(statusExpression.in(query.getInStatus()));
		}
		if (query.getNotInStatus() != null) {
			predicates.add(criteriaBuilder.not(statusExpression.in(query.getInStatus())));
		}
		if (query.getNullStatus() != null) {
			if (query.getNullStatus()) {
				predicates.add(criteriaBuilder.isNull(statusExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(statusExpression));
			}
		}
		/**
		 * createTimeExpression
		 */
		Expression<java.time.LocalDateTime> createTimeExpression = root.get(Admin.PROP_CREATE_TIME).as(java.time.LocalDateTime.class);
		if(query.hasCreateTimeBegin() && query.getCreateTimeBegin()!= null){
			if(!query.hasCreateTimeEnd() || query.getCreateTimeEnd() == null){
				predicates.add(criteriaBuilder.greaterThan(createTimeExpression, query.getCreateTimeBegin()));
			}else{
				predicates.add(criteriaBuilder.between(createTimeExpression, query.getCreateTimeBegin(), query.getCreateTimeEnd()));
			}			
		}
		if(query.hasCreateTimeEnd() && query.getCreateTimeEnd()!=null){
			if(!query.hasCreateTimeBegin() || query.getCreateTimeBegin() == null){
				predicates.add(criteriaBuilder.lessThan(createTimeExpression, query.getCreateTimeBegin()));
			}
		}							
		if (query.hasCreateTime()) {
			java.time.LocalDateTime value = query.getCreateTime();
			if( value != null){
				predicates.add(criteriaBuilder.equal(createTimeExpression, value));					
			}
		}
		if (query.hasNotEqCreateTime()) {
			java.time.LocalDateTime value = query.getNotEqCreateTime();
			predicates.add(criteriaBuilder.notEqual(createTimeExpression, value));
		}
		
		if (query.getInCreateTime() != null) {
			predicates.add(createTimeExpression.in(query.getInCreateTime()));
		}
		if (query.getNotInCreateTime() != null) {
			predicates.add(criteriaBuilder.not(createTimeExpression.in(query.getInCreateTime())));
		}
		if (query.getNullCreateTime() != null) {
			if (query.getNullCreateTime()) {
				predicates.add(criteriaBuilder.isNull(createTimeExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(createTimeExpression));
			}
		}
		/**
		 * updateTimeExpression
		 */
		Expression<java.time.LocalDateTime> updateTimeExpression = root.get(Admin.PROP_UPDATE_TIME).as(java.time.LocalDateTime.class);
		if(query.hasUpdateTimeBegin() && query.getUpdateTimeBegin()!= null){
			if(!query.hasUpdateTimeEnd() || query.getUpdateTimeEnd() == null){
				predicates.add(criteriaBuilder.greaterThan(updateTimeExpression, query.getUpdateTimeBegin()));
			}else{
				predicates.add(criteriaBuilder.between(updateTimeExpression, query.getUpdateTimeBegin(), query.getUpdateTimeEnd()));
			}			
		}
		if(query.hasUpdateTimeEnd() && query.getUpdateTimeEnd()!=null){
			if(!query.hasUpdateTimeBegin() || query.getUpdateTimeBegin() == null){
				predicates.add(criteriaBuilder.lessThan(updateTimeExpression, query.getUpdateTimeBegin()));
			}
		}							
		if (query.hasUpdateTime()) {
			java.time.LocalDateTime value = query.getUpdateTime();
			if( value != null){
				predicates.add(criteriaBuilder.equal(updateTimeExpression, value));					
			}
		}
		if (query.hasNotEqUpdateTime()) {
			java.time.LocalDateTime value = query.getNotEqUpdateTime();
			predicates.add(criteriaBuilder.notEqual(updateTimeExpression, value));
		}
		
		if (query.getInUpdateTime() != null) {
			predicates.add(updateTimeExpression.in(query.getInUpdateTime()));
		}
		if (query.getNotInUpdateTime() != null) {
			predicates.add(criteriaBuilder.not(updateTimeExpression.in(query.getInUpdateTime())));
		}
		if (query.getNullUpdateTime() != null) {
			if (query.getNullUpdateTime()) {
				predicates.add(criteriaBuilder.isNull(updateTimeExpression));
			} else {
				predicates.add(criteriaBuilder.isNotNull(updateTimeExpression));
			}
		}
		return predicates;
	}
	public String toString() {
		return ToStringBuilder.reflectionToString(this,ToStringStyle.MULTI_LINE_STYLE);
	}
	
}

